/**
 * 工具类
 **/
export const func = {
  /**
   * 字符串是否为空白 空白的定义如下： <br>
   * 1、为null <br>
   * 2、为不可见字符（如空格）<br>
   * 3、""<br>
   *
   * @param str 被检测的字符串
   * @return boolean 是否为空
   */
  isBlank: function (str: any) {
    return str === undefined || str == null || this.trim(str) === "";

  },
  /**
   * 字符串是否为非空白 空白的定义如下： <br>
   * 1、不为null <br>
   * 2、不为不可见字符（如空格）<br>
   * 3、不为""<br>
   *
   * @param str 被检测的字符串
   * @return boolean 是否为非空
   */
  isNotBlank: function (str: any) {
    // == 代表相同,=== 代表严格相同
    return false === func.isBlank(str);
  },
  /**
   * 字符串是否为空，空的定义如下:<br>
   * 1、为null <br>
   * 2、为""<br>
   *
   * @param obj 被检测的字符串
   * @return boolean 是否为空
   */
  isEmpty: function (obj: any) {
    if (obj === undefined || obj == null) {
      return true
    }
    if (obj instanceof Array) {
      return obj.length === 0
    } else if (obj instanceof Map) {
      return obj.size === 0
    } else if (obj instanceof Object) {
      return Object.keys(obj).length === 0
    }
    return obj === "";
  },
  /**
   * 字符串是否为非空白 空白的定义如下： <br>
   * 1、不为null <br>
   * 2、不为""<br>
   *
   * @param str 被检测的字符串
   * @return boolean 是否为非空
   */
  isNotEmpty: function (str: any) {
    return !func.isEmpty(str);
  },
  /**
   * 空对象转字符串
   *
   * @param str 被检查的字符串
   * @return string 原字符串或者空串
   */
  nullToStr: function (str: any) {
    if (func.isEmpty(str)) {
      return "";
    }
    return str;
  },
  /**
   * 空格截取
   *
   * @param str 截取的字符串
   * @return string
   */
  trim: function (str: any) {
    if (str == null) {
      return "";
    }
    return str.toString().replace(/(^\s*)|(\s*$)|\r|\n/g, "");
  },
  /**
   * 比较两个字符串（大小写敏感）
   *
   * @param str 字符串
   * @param that 比较的字符串
   * @return boolean
   */
  equals: function (str: any, that: any) {
    return str === that;
  },
  /**
   * 比较两个字符串（大小写不敏感）
   *
   * @param str 字符串
   * @param that 比较的字符串
   * @return boolean
   */
  equalsIgnoreCase: function (str: any, that: any) {
    return String(str).toUpperCase() === String(that).toUpperCase();
  },
  /**
   * 将字符串按指定字符分割
   *
   * @param str 字符串
   * @param sep 比较的字符串
   * @param maxLen 最大长度
   * @return string[] 分割后的数组
   */
  split: function (str: any, sep: any, maxLen: any) {
    if (func.isEmpty(str)) {
      return null;
    }
    const value = String(str).split(sep);
    return maxLen ? value.slice(0, maxLen - 1) : value;
  },
  /**
   * 字符串格式化(%s )
   *
   * @param str 字符串
   * @return 格式化后的字符串
   */
  sprintf: function (str: any) {
    let args = arguments, flag = true, i = 1;
    str = str.replace(/%s/g, function () {
      const arg = args[i++];
      if (typeof arg === 'undefined') {
        flag = false;
        return '';
      }
      return arg;
    });
    return flag ? str : '';
  },
  /**
   * 判断字符串是否是以start开头
   *
   * @param str 字符串
   * @param start 开始的字符串
   * @return boolean
   */
  startWith: function (str: any, start: any) {
    const reg = new RegExp("^" + start);
    return reg.test(str);
  },
  /**
   * 判断字符串是否是以end结尾
   *
   * @param str 字符串
   * @param end 结尾的字符串
   * @return boolean
   */
  endWith: function (str: any, end: any) {
    const reg = new RegExp(end + "$");
    return reg.test(str);
  },
  //生成指定个数的字符
  repeat: function (ch: any, repeatTimes: any) {
    let result = "";
    for (let i = 0; i < repeatTimes; i++) {
      result += ch;
    }
    return result;
  },
  deleteWhitespace: function (input: any) {
    return input.replace(/\s+/g, '');
  },
  rightPad: function (input: any, size: any, padStr: any) {
    return input + this.repeat(padStr, size);
  },
  leftPad: function (input: any, size: any, padStr: any) {
    return this.repeat(padStr, size) + input;
  },
  //首小写字母转大写
  capitalize: function (input: any) {
    if (input == null || input.length === 0) {
      return input;
    }
    return input.replace(/^[a-z]/, function (matchStr: any) {
      return matchStr.toLocaleUpperCase();
    });
  },
  //首大写字母转小写
  uncapitalize: function (input: any) {
    if (input == null || input.length === 0) {
      return input;
    }
    return input.replace(/^[A-Z]/, function (matchStr: any) {
      return matchStr.toLocaleLowerCase();
    });
  },
  //大写转小写，小写转大写
  swapCase: function (input: any) {
    return input.replace(/[a-z]/ig, function (matchStr: any) {
      if (matchStr >= 'A' && matchStr <= 'Z') {
        return matchStr.toLocaleLowerCase();
      } else if (matchStr >= 'a' && matchStr <= 'z') {
        return matchStr.toLocaleUpperCase();
      }
    });
  },
  //统计含有的子字符串的个数
  countMatches: function (input: any, sub: any) {
    if (this.isEmpty(input) || this.isEmpty(sub)) {
      return 0;
    }
    let count = 0;
    let index = 0;
    while ((index = input.indexOf(sub, index)) !== -1) {
      index += sub.length;
      count++;
    }
    return count;
  },
  //只包含字母
  isAlpha: function (input: any) {
    return /^[a-z]+$/i.test(input);
  },
  //只包含字母、空格
  isAlphaSpace: function (input: any) {
    return /^[a-z\s]*$/i.test(input);
  },
  //只包含字母、数字
  isAlphanumeric: function (input: any) {
    return /^[a-z0-9]+$/i.test(input);
  },
  //只包含字母、数字和空格
  isAlphanumericSpace: function (input: any) {
    return /^[a-z0-9\s]*$/i.test(input);
  },
  //数字
  isNumeric: function (input: any) {
    return /^(?:[1-9]\d*|0)(?:\.\d+)?$/.test(input);
  },
  //小数
  isDecimal: function (input: any) {
    return /^[-+]?(?:0|[1-9]\d*)\.\d+$/.test(input);
  },
  //负小数
  isNegativeDecimal: function (input: any) {
    return /^\-?(?:0|[1-9]\d*)\.\d+$/.test(input);
  },
  //正小数
  isPositiveDecimal: function (input: any) {
    return /^\+?(?:0|[1-9]\d*)\.\d+$/.test(input);
  },
  //整数
  isInteger: function (input: any) {
    return /^[-+]?(?:0|[1-9]\d*)$/.test(input);
  },
  //正整数:any
  isPositiveInteger: function (input: any) {
    return /^\+?(?:0|[1-9]\d*)$/.test(input);
  },
  //负整数
  isNegativeInteger: function (input: any) {
    return /^\-?(?:0|[1-9]\d*)$/.test(input);
  },
  //只包含数字和空格
  isNumericSpace: function (input: any) {
    return /^[\d\s]*$/.test(input);
  },
  isWhitespace: function (input: any) {
    return /^\s*$/.test(input);
  },
  isAllLowerCase: function (input: any) {
    return /^[a-z]+$/.test(input);
  },
  isAllUpperCase: function (input: any) {
    return /^[A-Z]+$/.test(input);
  },
  defaultString: function (input: any, defaultStr: any) {
    return input == null ? defaultStr : input;
  },
  defaultIfBlank: function (input: any, defaultStr: any) {
    return this.isBlank(input) ? defaultStr : input;
  },
  defaultIfEmpty: function (input: any, defaultStr: any) {
    return this.isEmpty(input) ? defaultStr : input;
  },
  //字符串反转
  reverse: function (input: any) {
    if (this.isBlank(input)) {
      input;
    }
    return input.split("").reverse().join("");
  },
  //删掉特殊字符(英文状态下)
  removeSpecialCharacter: function (input: any) {
    return input.replace(/[!-/:-@\[-`{-~]/g, "");
  },
  //只包含特殊字符、数字和字母（不包括空格，若想包括空格，改为[ -~]）
  isSpecialCharacterAlphanumeric: function (input: any) {
    return /^[!-~]+$/.test(input);
  },
  // /**
  //  * @param {String} message
  //  * @param {Array} arr
  //  * 消息格式化
  //  */
  // format: function (message:any, arr:any) {
  //   return message.replace(/{(\d+)}/g, function (matchStr:string, group1:any) {
  //     return arr[group1];
  //   });
  // },
  /**
   * 把连续出现多次的字母字符串进行压缩。如输入:aaabbbbcccccd 输出:3a4b5cd
   * @param {String} input
   * @param {Boolean} ignoreCase : true or false
   */
  compressRepeatedStr: function (input: any, ignoreCase: any) {
    const pattern = new RegExp("([a-z])\\1+", ignoreCase ? "ig" : "g");
    return input.replace(pattern, function (matchStr: any, group1: any) {
      return matchStr.length + group1;
    });
  },
  //中文校验
  isChinese: function (input: any) {
    return /^[\u4E00-\u9FA5]+$/.test(input);
  },
  //去掉中文字符
  removeChinese: function (input: any) {
    return input.replace(/[\u4E00-\u9FA5]+/gm, "");
  },
  //转义元字符
  escapeMetacharacter: function (input: any) {
    const metacharacter = "^$()*+.[]|\\-?{}|";
    if (metacharacter.indexOf(input) >= 0) {
      input = "\\" + input;
    }
    return input;
  },
  //转义字符串中的元字符
  escapeMetacharacterOfStr: function (input: any) {
    return input.replace(/[\^\$\*\+\.\|\\\-\?\{\}\|]/gm, "\\$&");
  },
  //实现简单雪花ID
  getId: function(machineId = 1){
    const time = Date.now() - 1609459200000; // 从 2021-01-01 开始计算（减少位数）
    const random = Math.floor(Math.random() * 4096); // 12位随机数
    let id= (time << 22) | (machineId << 12) | random; // 组合成 64 位 ID
    return id<0? '0'+Math.abs(id):'1'+id
  },
  //获取当前路由路径
  getCurrentRoutePath:function (treeArray, path, options = { childrenKey: 'children', nameKey: 'path'}) {
    const {
      childrenKey = 'children',
      nameKey = 'path'
    } = options;
    if (!path || !treeArray) return null;
    const parts = path.split('/');
    let currentLevel = treeArray;
    const pathNodes = [];
    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      if (part === '') {
        continue;
      }
      const foundNode = currentLevel.find(node => node[nameKey] === part || node[nameKey] === '/' + part);

      if (!foundNode) return null;

      pathNodes.push(foundNode);

      if (i < parts.length - 1) {
        if (!foundNode[childrenKey]) return null;
        currentLevel = foundNode[childrenKey];
      }
    }
    return pathNodes[pathNodes.length - 1];
  }
};
